import models from '../../models';
import { QueryWhereConf, AddAccessRouteError } from 'definitions/access-route';
import { QueryAllConf } from 'definitions/common';
import { initRedis } from '../../bin/init';

const { AdminAccessRouter, AdminRole } = models;

export default function (router) {
  /**
   * 获取权限列表
   * @param {String} role 角色ID
   * @param {Boolean} all 是否查询全部
   * @param {Number} page 查询页数
   * @param {Number} limit 每页限制数
   */
  router.get('/api/admin/access-route', async ctx => {
    const { role, sorter, all } = ctx.request.query;
    const { page, limit } = ctx.parsePageAndLimit(ctx.request.query);

    let whereConf: QueryWhereConf = {};
    if (role) {
      whereConf.role_id = role;
    }

    // 排序规则
    let order = [['created_at', 'DESC']];
    if (sorter) {
      const sortName = sorter.split('_')[0].replace('createdAt', 'created_at').replace('updatedAt', 'updated_at');
      const sortFunc = sorter.split('_')[1].replace('ascend', 'ASC').replace('descend', 'DESC');
      order = [[sortName, sortFunc]];
    }

    // 是否获取全部数据
    const allConf: QueryAllConf = {};
    if (!all) {
      allConf.offset = (page - 1) * limit;
      allConf.limit = limit;
    }

    const accessRoute = await AdminAccessRouter.findAndCountAll({
      ...allConf,
      where: whereConf,
      include: [{ model: models.AdminRole, attributes: ['id', 'name'], as: 'role' }],
      order: order
    });
    await ctx.json(true, '获取角色路由成功', { total: accessRoute.count, list: accessRoute.rows });
  });

  /**
   * 新增权限
   * @param {String} role 角色ID
   * @param {String} route 角色可以访问的路由
   */
  router.post('/api/admin/access-route', async ctx => {
    const { role = '', routers = [] } = ctx.request.body;
    // 验证参数
    let error: AddAccessRouteError = {};
    if (!role) error.role = '请选择角色';
    if (!(await AdminRole.findByPk(role))) error.role = '角色不存在';
    if (await AdminAccessRouter.isRepeat('role_id', role)) error.role = '角色已经配置路由了';
    if (!(routers instanceof Array && routers.length > 0)) error.routers = '请选择角色可以访问的路由';
    if (JSON.stringify(error) !== '{}') {
      await ctx.json(false, 'validate-error', error);
      return;
    }

    // 创建权限
    const newAccessRoute = await AdminAccessRouter.create({
      role_id: role,
      routers: routers
    });

    if (newAccessRoute && newAccessRoute.id) {
      // 更新缓存中的权限数据
      initRedis();
      await ctx.json(true, '角色路由创建成功', newAccessRoute);
    } else {
      await ctx.json(false, '角色路由创建失败');
    }
  });

  /**
   * 修改权限
   * @param {String} role 角色ID
   * @param {String} route 角色可以访问的路由
   */
  router.put('/api/admin/access-route/:id', async ctx => {
    const { role = '', routers = [] } = ctx.request.body;
    const accessRouteId = ctx.params.id;
    // 验证参数
    let error: AddAccessRouteError = {};
    let params: AddAccessRouteError = {};

    if (role) {
      if (!(await AdminRole.findByPk(role))) error.role = '角色不存在';
      params.role = role;
    }

    if (routers) {
      if (!(routers instanceof Array && routers.length > 0)) error.routers = '请选择角色可以访问的路由';
      params.routers = routers;
    }

    if (JSON.stringify(error) !== '{}') {
      await ctx.json(false, 'validate-error', error);
      return;
    }

    // 更新权限
    const updateResult = await AdminAccessRouter.update(params, {
      where: { id: accessRouteId }
    });
    if (updateResult[0] === 1) {
      await ctx.json(true, '更新角色路由成功');
    } else {
      await ctx.json(false, '更新角色路由失败');
    }
  });

  /**
   * 删除角色路由
   */
  router.delete('/api/admin/access-route/:id', async ctx => {
    const { id } = ctx.params;
    // 删除角色路由
    const deleteResult = await AdminAccessRouter.destroy({ where: { id } });
    if (deleteResult === 1) {
      await ctx.json(true, '删除权限成功');
    } else {
      await ctx.json(false, '删除权限失败');
    }
  });
}
